﻿package mortal.game.scene3D.map3D.AstarAnyDirection.data
{
    import __AS3__.vec.*;
    import flash.geom.*;

    public class GeomUtil extends Object
    {
        private static var v1:Vector2f = new Vector2f();
        private static var v2:Vector2f = new Vector2f();
        private static var v3:Vector2f = new Vector2f();
        private static var v4:Vector2f = new Vector2f();
        private static var t1:Vector2f = new Vector2f();
        private static var t2:Vector2f = new Vector2f();
        private static var t3:Vector2f = new Vector2f();

        public function GeomUtil()
        {
            return;
        }// end function

        public static function isLimitLineCross(param1:Vector2f, param2:Vector2f, param3:Vector2f, param4:Vector2f) : Boolean
        {
            param1.subtract(param3, t1);
            param4.subtract(param3, t2);
            param2.subtract(param3, t3);
            if (t1.crossMult(t2) * t3.crossMult(t2) > 1e-005)
            {
                return false;
            }
            param4.subtract(param1, t1);
            param2.subtract(param1, t2);
            param3.subtract(param1, t3);
            if (t1.crossMult(t2) * t3.crossMult(t2) > 1e-005)
            {
                return false;
            }
            return true;
        }// end function

        public static function isLineP3P4CrossSegmentsP1P2(param1:Vector2f, param2:Vector2f, param3:Vector2f, param4:Vector2f) : Boolean
        {
            param1.subtract(param3, t1);
            param4.subtract(param3, t2);
            param2.subtract(param3, t3);
            if (t1.crossMult(t2) * t3.crossMult(t2) > 1e-006)
            {
                return false;
            }
            return true;
        }// end function

        public static function calcSegmentsCrossPoint(param1:Point, param2:Point, param3:Point, param4:Point, param5:Point, param6:Boolean = true) : Boolean
        {
            v1.fromPoint(param1);
            v2.fromPoint(param2);
            v3.fromPoint(param3);
            v4.fromPoint(param4);
            if (!param6)
            {
                if (!isLimitLineCross(v1, v2, v3, v4))
                {
                    return false;
                }
            }
            v1.subtract(v2, t1);
            v3.subtract(v4, t2);
            if (t1.crossMult(t2) == 0)
            {
                return false;
            }
            param5.x = param1.x;
            param5.y = param1.y;
            var _loc_7:* = ((param1.x - param3.x) * (param3.y - param4.y) - (param1.y - param3.y) * (param3.x - param4.x)) / ((param1.x - param2.x) * (param3.y - param4.y) - (param1.y - param2.y) * (param3.x - param4.x));
            param5.x = param5.x + (param2.x - param1.x) * _loc_7;
            param5.y = param5.y + (param2.y - param1.y) * _loc_7;
            return true;
        }// end function

        public static function calcLineCrossPoint(param1:Vector2f, param2:Vector2f, param3:Vector2f, param4:Vector2f, param5:Vector2f) : Boolean
        {
            var _loc_6:* = param2._x - param1._x;
            var _loc_7:* = param2._y - param1._y;
            var _loc_8:* = param4._x - param3._x;
            var _loc_9:* = param4._y - param3._y;
            var _loc_10:* = _loc_7 / _loc_6;
            var _loc_11:* = _loc_9 / _loc_8;
            if (_loc_6 == 0)
            {
                if (_loc_8 == 0)
                {
                    return false;
                }
                param5._x = param1._x;
                param5._y = _loc_11 * (param5._x - param3._x) + param3._y;
                return true;
            }
            else
            {
                if (_loc_8 == 0)
                {
                    param5._x = param3._x;
                    param5._y = _loc_10 * (param5._x - param1._x) + param1._y;
                    return true;
                }
                if (_loc_10 == _loc_11)
                {
                    return false;
                }
                param5._x = (param3._y - param1._y - (_loc_11 * param3._x - _loc_10 * param1._x)) / (_loc_10 - _loc_11);
            }
            param5._y = _loc_10 * (param5._x - param1._x) + param1._y;
            return true;
        }// end function

        public static function isRectCrossVertexs(param1:int, param2:int, param3:int, param4:int, param5:Vector.<Vector2f>) : Boolean
        {
            var _loc_6:* = param5.length;
            if (_loc_6 == 2)
            {
                _loc_6 = 1;
            }
            var _loc_7:int = 0;
            while (_loc_7 < _loc_6)
            {
                
                v1 = param5[_loc_7];
                if (_loc_7 == (param5.length - 1))
                {
                    v2 = param5[0];
                }
                else
                {
                    v2 = param5[(_loc_7 + 1)];
                }
                v3.x = param1;
                v3.y = param2;
                v4.x = param1 + param3;
                v4.y = param2;
                if (GeomUtil.isLimitLineCross(v1, v2, v3, v4))
                {
                    return true;
                }
                v3.x = param1 + param3;
                v3.y = param2 + param4;
                v4.x = param1 + param3;
                v4.y = param2;
                if (GeomUtil.isLimitLineCross(v1, v2, v3, v4))
                {
                    return true;
                }
                v3.x = param1 + param3;
                v3.y = param2 + param4;
                v4.x = param1;
                v4.y = param2 + param4;
                if (GeomUtil.isLimitLineCross(v1, v2, v3, v4))
                {
                    return true;
                }
                v3.x = param1;
                v3.y = param2;
                v4.x = param1;
                v4.y = param2 + param4;
                if (GeomUtil.isLimitLineCross(v1, v2, v3, v4))
                {
                    return true;
                }
                _loc_7++;
            }
            return false;
        }// end function

        public static function calcNearestPointDistance(param1:Point, param2:Point, param3:Point) : Number
        {
            var _loc_4:* = calcDistance(param2.x, param2.y, param3.x, param3.y);
            var _loc_5:* = calcDistance(param1.x, param1.y, param3.x, param3.y);
            var _loc_6:* = calcDistance(param1.x, param1.y, param2.x, param2.y);
            if (_loc_4 * _loc_5 < 1e-005)
            {
                return 0;
            }
            if (_loc_4 * _loc_4 > _loc_5 * _loc_5 + _loc_6 * _loc_6)
            {
                return _loc_5;
            }
            if (_loc_5 * _loc_5 > _loc_4 * _loc_4 + _loc_6 * _loc_6)
            {
                return _loc_4;
            }
            var _loc_7:* = (_loc_4 + _loc_5 + _loc_6) * 0.5;
            var _loc_8:* = Math.sqrt(_loc_7 * (_loc_7 - _loc_4) * (_loc_7 - _loc_5) * (_loc_7 - _loc_6));
            return 2 * _loc_8 / _loc_6;
        }// end function

        public static function calcDistance(param1:Number, param2:Number, param3:Number, param4:Number) : Number
        {
            param1 = param1 - param3;
            param2 = param2 - param4;
            return Math.sqrt(param1 * param1 + param2 * param2);
        }// end function

        public static function calcDistance2(param1:Vector2f, param2:Vector2f) : Number
        {
            t1._x = param1._x - param2._x;
            t1._y = param1._y - param2._y;
            return Math.sqrt(t1._x * t1._x + t1._y * t1._y);
        }// end function

        public static function calcGridesPassLine(param1:Number, param2:Number, param3:Number, param4:Number, param5:Number = 1, param6:Number = 1, param7:Boolean = false) : Array
        {
            var _loc_19:int = 0;
            var _loc_8:Array = [];
            var _loc_9:* = Math.floor(param1 / param5);
            var _loc_10:* = Math.floor(param2 / param6);
            var _loc_11:* = Math.ceil(param3 / param5);
            var _loc_12:* = Math.ceil(param4 / param6);
            var _loc_13:* = param3 - param1;
            var _loc_14:* = param4 - param2;
            var _loc_15:* = _loc_13 > 0 ? (1) : (-1);
            var _loc_16:* = _loc_14 > 0 ? (1) : (-1);
            var _loc_17:* = new Vector.<Vector2f>;
            _loc_17.push(new Vector2f(param1 + 0.5 * param5, param2 + 0.5 * param6), new Vector2f(param3 + 0.5 * param5, param4 + 0.5 * param6));
            var _loc_18:* = _loc_10;
            while (_loc_18 != _loc_12 + _loc_16)
            {
                
                _loc_19 = _loc_9;
                while (_loc_19 != _loc_11 + _loc_15)
                {
                    
                    if (_loc_18 == _loc_12 && _loc_19 == _loc_11 && param7)
                    {
                        _loc_8.push(new Point(_loc_19 * param5, _loc_18 * param6));
                        break;
                    }
                    if (GeomUtil.isRectCrossVertexs(_loc_19, _loc_18, 1, 1, _loc_17))
                    {
                        _loc_8.push(new Point(_loc_19 * param5, _loc_18 * param6));
                    }
                    _loc_19 = _loc_19 + _loc_15;
                }
                _loc_18 = _loc_18 + _loc_16;
            }
            return _loc_8;
        }// end function

        public static function calcLinePassGridesFastLeftTop(param1:int, param2:int, param3:int, param4:int) : Vector.<int>
        {
            var _loc_14:int = 0;
            var _loc_15:int = 0;
            var _loc_16:Number = NaN;
            var _loc_17:int = 0;
            var _loc_5:* = param3 - param1;
            var _loc_6:* = param4 - param2;
            var _loc_7:* = new Vector.<int>;
            _loc_7.push(param1, param2);
            var _loc_8:* = _loc_6 / _loc_5;
            var _loc_9:* = Math.abs(_loc_6);
            var _loc_10:* = Math.abs(_loc_5);
            var _loc_11:* = _loc_5 / _loc_10;
            var _loc_12:* = _loc_6 / _loc_9;
            var _loc_13:* = getGCM(_loc_9, _loc_10);
            _loc_6 = _loc_6 / _loc_13;
            _loc_5 = _loc_5 / _loc_13;
            var _loc_18:Array = [];
            if (_loc_10 > _loc_9)
            {
                _loc_15 = param2 + _loc_12;
                while (_loc_15 != param4)
                {
                    
                    _loc_16 = (_loc_15 - param2) / _loc_8 + param1;
                    _loc_18.push(_loc_16);
                    _loc_15 = _loc_15 + _loc_12;
                }
                _loc_17 = 0;
                _loc_15 = param2;
                if (_loc_12 < 0)
                {
                    _loc_15 = param2 + _loc_12;
                }
                _loc_14 = param1;
                while (_loc_14 != param3 + _loc_11)
                {
                    
                    _loc_7.push(_loc_14, _loc_15);
                    _loc_16 = _loc_18[_loc_17];
                    if (Math.abs(_loc_14 - _loc_16) < 0.5 || _loc_16 + _loc_11 * 0.5 == _loc_14)
                    {
                        _loc_15 = _loc_15 + _loc_12;
                        _loc_17++;
                        _loc_7.push(_loc_14, _loc_15);
                    }
                    _loc_14 = _loc_14 + _loc_11;
                }
            }
            else if (_loc_10 == _loc_9)
            {
                _loc_14 = 1;
                while (_loc_14 < _loc_10)
                {
                    
                    _loc_7.push(param1 + _loc_11 * _loc_14, param2 + _loc_12 * _loc_14);
                    _loc_14++;
                }
            }
            else
            {
                _loc_14 = param1 + _loc_11;
                while (_loc_14 != param3)
                {
                    
                    _loc_16 = _loc_8 * (_loc_14 - param1) + param2;
                    _loc_18.push(_loc_16);
                    _loc_14 = _loc_14 + _loc_11;
                }
                _loc_17 = 0;
                _loc_14 = param1;
                if (_loc_11 < 0)
                {
                    _loc_14 = param1 + _loc_11;
                }
                _loc_15 = param2;
                while (_loc_15 != param4 + _loc_12)
                {
                    
                    _loc_7.push(_loc_14, _loc_15);
                    _loc_16 = _loc_18[_loc_17];
                    if (Math.abs(_loc_15 - _loc_16) < 0.5 || _loc_16 + _loc_12 * 0.5 == _loc_15)
                    {
                        _loc_14 = _loc_14 + _loc_11;
                        _loc_17++;
                        _loc_7.push(_loc_14, _loc_15);
                    }
                    _loc_15 = _loc_15 + _loc_12;
                }
            }
            _loc_7.push(param3, param4);
            return _loc_7;
        }// end function

        public static function calcLinePassGridesFastMidle(param1:int, param2:int, param3:int, param4:int) : Vector.<int>
        {
            var _loc_15:Number = NaN;
            var _loc_16:Number = NaN;
            var _loc_17:Number = NaN;
            var _loc_18:int = 0;
            var _loc_20:Number = NaN;
            var _loc_5:* = new Vector.<int>;
            _loc_5.push(param1, param2);
            var _loc_6:* = param3 - param1;
            var _loc_7:* = param4 - param2;
            var _loc_8:* = _loc_7 / _loc_6;
            var _loc_9:* = Math.abs(_loc_7);
            var _loc_10:* = Math.abs(_loc_6);
            var _loc_11:* = _loc_6 / _loc_10;
            var _loc_12:* = _loc_7 / _loc_9;
            var _loc_13:* = _loc_11 * 0.5;
            var _loc_14:* = _loc_12 * 0.5;
            var _loc_19:Array = [];
            if (_loc_10 > _loc_9)
            {
                _loc_20 = param4 + _loc_14;
                _loc_16 = param2 + _loc_14;
                while (_loc_16 != _loc_20)
                {
                    
                    _loc_17 = (_loc_16 - param2) / _loc_8 + param1;
                    _loc_19.push(_loc_17);
                    _loc_16 = _loc_16 + _loc_12;
                }
                _loc_18 = 0;
                _loc_16 = param2;
                _loc_17 = _loc_19[_loc_18];
                _loc_15 = param1 + _loc_11;
                while (_loc_15 != param3)
                {
                    
                    _loc_5.push(_loc_15, _loc_16);
                    if (Math.abs(_loc_15 - _loc_17) == 0.5)
                    {
                        if (_loc_7 < 0)
                        {
                            _loc_5.push(_loc_15 + _loc_11, _loc_16);
                        }
                        else
                        {
                            _loc_5.push(_loc_15, _loc_16 + _loc_12);
                        }
                        _loc_16 = _loc_16 + _loc_12;
                        _loc_18++;
                        _loc_17 = _loc_19[_loc_18];
                    }
                    else if (Math.abs(_loc_15 - _loc_17) < 0.5)
                    {
                        _loc_16 = _loc_16 + _loc_12;
                        _loc_18++;
                        _loc_17 = _loc_19[_loc_18];
                        _loc_5.push(_loc_15, _loc_16);
                    }
                    _loc_15 = _loc_15 + _loc_11;
                }
            }
            else if (_loc_10 == _loc_9)
            {
                if (_loc_7 < 0)
                {
                    _loc_5.push(param1 + _loc_11, param2);
                }
                else
                {
                    _loc_5.push(param1, param2 + _loc_12);
                }
                _loc_15 = param1 + _loc_11;
                _loc_16 = param2 + _loc_12;
                while (_loc_15 != param3)
                {
                    
                    if (_loc_7 < 0)
                    {
                        _loc_5.push(_loc_15 + _loc_11, _loc_16);
                    }
                    else
                    {
                        _loc_5.push(_loc_15, _loc_16 + _loc_12);
                    }
                    _loc_5.push(_loc_15, _loc_16);
                    _loc_15 = _loc_15 + _loc_11;
                    _loc_16 = _loc_16 + _loc_12;
                }
            }
            else
            {
                _loc_20 = param3 + _loc_13;
                _loc_15 = param1 + _loc_13;
                while (_loc_15 != _loc_20)
                {
                    
                    _loc_17 = (_loc_15 - param1) * _loc_8 + param2;
                    _loc_19.push(_loc_17);
                    _loc_15 = _loc_15 + _loc_11;
                }
                _loc_18 = 0;
                _loc_15 = param1;
                _loc_17 = _loc_19[_loc_18];
                _loc_16 = param2 + _loc_12;
                while (_loc_16 != param4)
                {
                    
                    _loc_5.push(_loc_15, _loc_16);
                    if (Math.abs(_loc_16 - _loc_17) == 0.5)
                    {
                        if (_loc_7 < 0)
                        {
                            _loc_5.push(_loc_15 + _loc_11, _loc_16);
                        }
                        else
                        {
                            _loc_5.push(_loc_15, _loc_16 + _loc_12);
                        }
                        _loc_15 = _loc_15 + _loc_11;
                        _loc_18++;
                        _loc_17 = _loc_19[_loc_18];
                    }
                    else if (Math.abs(_loc_16 - _loc_17) < 0.5)
                    {
                        _loc_15 = _loc_15 + _loc_11;
                        _loc_18++;
                        _loc_17 = _loc_19[_loc_18];
                        _loc_5.push(_loc_15, _loc_16);
                    }
                    _loc_16 = _loc_16 + _loc_12;
                }
            }
            _loc_5.push(param3, param4);
            return _loc_5;
        }// end function

        public static function getGCM(param1:int, param2:int) : int
        {
            var _loc_3:int = 0;
            if (param1 < param2)
            {
                param1 = param1 + param2;
                param2 = param1 - param2;
                param1 = param1 - param2;
            }
            while (param2 != 0)
            {
                
                _loc_3 = param1 % param2;
                param1 = param2;
                param2 = _loc_3;
            }
            return param1;
        }// end function

        public static function getPointByDistance(param1:Number, param2:Number, param3:Number, param4:Number, param5:Number, param6:Boolean = true) : Point
        {
            var _loc_9:Number = NaN;
            var _loc_7:* = new Point();
            var _loc_8:* = calcDistance(param1, param2, param3, param4);
            if (_loc_8 <= param5 && param6)
            {
                _loc_7.x = param3;
                _loc_7.y = param4;
            }
            else
            {
                _loc_9 = param5 / _loc_8;
                _loc_7.x = param1 + _loc_9 * (param3 - param1);
                _loc_7.y = param2 + _loc_9 * (param4 - param2);
            }
            return _loc_7;
        }// end function

    }
}
